/* Pour lancer cette classe 
 * B1 : lancer la methode 'lireListeStop(String fichier)'
 * B2 : updateNumMaxDocument()
 * B3 : updateNomFileIndex()
 * B4 : updateNomFileInverse()
 * B2 : lancer 'Run(String fichier,int ID)'
 * 
 * */

import java.util.*;
import java.io.*;
class Indexation
{
	private static String ponctuations = "[^A-Za-z0-9]";
	private static String separateur = " ";
	private static String not = "!";
	
	// Supprimer des espaces entre des mots 
	private static String expression = "\\s+";
	
	// Traiter sur le fichier
	private static Traitement_File file = new Traitement_File();
	
	
	private int id;
	private String fileDictionaire = null;
	private String fileInverse = null;
	private String fileIndex = null;
	
	private static Hashtable listeDeTerme = new Hashtable();
	private static Vector listeStop = new Vector();
	
	private static Hashtable listeDeDocument = new Hashtable();
	
	private static RandomAccessFile raf; 
	private int NumMaxDocument = 0;
	
	public void updateID(int ID)
	{
		id = ID;
	}
	public int getID()
	{
		return id;
	}
	
	public void updateNomFileDictionaire(String nom)
	{
		fileDictionaire = nom;
	}
	
	public String getNomFileDictionaire()
	{
		return fileDictionaire;
	}
	
	public void updateNomFileInverse(String nom)
	{
		fileInverse = nom;
	}
	
	public String getNomFileInverse()
	{
		return fileInverse;
	}
	
	public void updateNomFileIndex(String nom)
	{
		fileIndex = nom;
	}
	
	public String getNomFileIndex()
	{
		return fileIndex;
	}
	
	public static Hashtable getListeDeTerme()
	{
		return listeDeTerme;
	}
	
	public static Vector getlisteStop()
	{
		return listeStop;
	}
	
	public static Hashtable getListeDeDocument()
	{
		return listeDeDocument;
	}
		
	// Lire le fichier Stop-list
	public static void lireListeStop(String fichier)
	{
		
		listeStop.addAll(file.lireTxt(fichier));
	}
	
	public int getNumMaxDocument()
	{
		return NumMaxDocument;
	}
	
	public void updateNumMaxDocument(int max)
	{
		NumMaxDocument = max;
	}
	
	
	// Enlever les ponctuations 
	private String enleverPonctuation(String linge) 
	{
		// Remplacer les mots n'est ni numero ni characteres par l'espace 
		linge = linge.replaceAll(ponctuations,separateur);		
		
		// Supprimer des espaces entre des mots 
		// ex : A     B ==> A B
		linge = linge.replaceAll(expression, separateur);
		
		// Passage en minuscule		
		linge = linge.toLowerCase().trim();		
		
		return linge;
	}
	
	// La methode principale 
	@SuppressWarnings("unchecked")
	public void Telecharger(String fichier,int ID)
	{
		// Sauvegarder une hastable contient le nom de fichier 
		// ID : nom fichier
		listeDeDocument.put( ID,fichier);
		
		
		this.updateID(ID);
		Vector listeTerme_Temp = new Vector();

		
		// Lire le ficher contient les texts
		Vector lignes = new Vector();
		lignes.addAll(file.lireTxt(fichier));
		
		
		//=====================================================================================//
		//=========== Pré-traitements &&  Extraction des index des documents ==================//
		//=====================================================================================//	
		
		//*********** Tokenisation *****************//					
		for(int i = 0 ; i < lignes.size(); i++)
		{
			String linge = (String)lignes.elementAt(i);
						
			// enlève les ponctuations par ligne	
			linge = enleverPonctuation(linge);						
			
			String [] termes = linge.split( separateur );		
			for(int j = 0 ; j < termes.length ; j++)
			{
				Term x = new Term(termes[j],this.id);
				
				// Extraction des index des documents		
				if(!listeTerme_Temp.contains(x))
				{						
					listeTerme_Temp.addElement(x);		
					
//					System.out.println("Terme:" + x.getMot());
				}
			}
			
		}				
		
		
		//*********** Comparaison avec la stop-list *****************//	
		
		// Supprimer les termes apparait dans la list STOP	
		Vector stop = new Vector();	
		for(int i = 0 ; i < listeStop.size(); i++)
		{
			String chain = (String)listeStop.elementAt(i);
			Term temp = new Term(chain,this.id);
			stop.add(temp);
		}
		listeTerme_Temp.removeAll(stop);
				
			
		//=======================================//
		//=========== Tri des index  ============//
		//======================================//		
		Collections.sort(listeTerme_Temp);
					
		
		//=====================================================================//
		//=========== Faire le fichier index - Inverse ========================//
		//=====================================================================//
		openFielInverse();
		for(int i = 0 ; i < listeTerme_Temp.size();i++)
		{
			Term temp = (Term)listeTerme_Temp.elementAt(i);
			if(listeDeTerme.get(temp.getMot()) == null)
			{
				
				try
				{
						long position = raf.length();
						listeDeTerme.put(temp.getMot(), position);
						
//						System.out.println("Terme:" + temp.getMot());
//						System.out.println("Position:"+position);
						this.saveFileInverse(NumMaxDocument, position, this.id);
						
						
				} 
				catch (IOException e)
				{
						// TODO Auto-generated catch block
						e.printStackTrace();
				}
			
				
			}
			else
			{
				Long position = (Long) listeDeTerme.get(temp.getMot());
				
				try {
//					System.out.println("Terme:" + temp.getMot());
//					System.out.println("Position:"+position);
					
					this.saveFileInverse(NumMaxDocument, position, this.id);
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}		
		closeFileInverse();
	
		
	}
	
	//***************************************************************************//
	//************** Sauvegarder - Telecharger le fichier index *****************//
	//***************************************************************************//
	
	// ID : nom document
	public void saveFileIndex()
	{
		// Savegerder le nombre document : 
		listeDeDocument.put("NumMaxDocument", this.NumMaxDocument);
		try{
			
			// Sauvegarder en binaire 
			  FileOutputStream fileOut = new FileOutputStream(fileIndex);
			  ObjectOutputStream out = new ObjectOutputStream(fileOut);	
			  out.writeObject(listeDeDocument);		
			  out.close();
			  fileOut.close();
			  
			// Sauvegarder en TXT			  
			  Writer output = new BufferedWriter(new FileWriter(fileIndex.replaceAll(".in", ".txt")));
		      try
		      {
		    	 output.write("NumMaxDocument:" + this.NumMaxDocument+"\n"); 
		       	 Set set = listeDeDocument.keySet(); // get set-view of keys 
			     Iterator itr = set.iterator(); 
				 while(itr.hasNext()) 
				 { 
					 try
					 {
						 int ID =  (Integer) itr.next(); 
						 String str = ID + ": " + listeDeDocument.get(ID) +"\n"; 
						 output.write(str);
					 }
					 catch (ClassCastException e)
					 {
						 
					 }					
				 }		  
		      }
		      finally
		      {
		           output.close();
		      }		  
		}
		catch(FileNotFoundException e){
		  e.printStackTrace();
		 }
		catch(IOException e){
		 e.printStackTrace();
		}

		
		
	}
	public void loadFileIndex()
	{
			
			  try
			  {		
				  FileInputStream fileIn = new FileInputStream(fileIndex);
				  ObjectInputStream in = new ObjectInputStream(fileIn);		
				  listeDeDocument = (Hashtable)in.readObject();				  
				  
				  // Load le nombre document : 			  
				  this.updateNumMaxDocument( (Integer) listeDeDocument.get("NumMaxDocument") );
				  
				  in.close();
				  fileIn.close();
			  }
			  catch(ClassNotFoundException e){
				  e.printStackTrace();
			  }
			  
			  catch(FileNotFoundException e){
				  e.printStackTrace();
			  }
			  
			  catch(IOException e){
				  e.printStackTrace();
			  }
	}
	
	//***************************************************************************//
	//************** Sauvegarder - Telecharger le fichier dictionnaire **********//
	//***************************************************************************//
	//  Sauvegarder 'listeDeTerme' : Hastable	
	// Termes : position dans le file inverse
	public void saveFileDictionaire()
	{
					
		try{
	
			// Sauvegarder en binaire
			  FileOutputStream fileOut = new FileOutputStream(fileDictionaire);
			  ObjectOutputStream out = new ObjectOutputStream(fileOut);	
			  out.writeObject(listeDeTerme);	
			  out.close();
			  fileOut.close();
			  		  
			// Sauvegarder en TXT
			  Vector test_txt = new Vector();
			  Set set = listeDeTerme.keySet(); // get set-view of keys 
			  Iterator itr = set.iterator(); 
			  while(itr.hasNext()) 
			  { 
			  	String str = (String) itr.next(); 
			  	str = str + ": " + listeDeTerme.get(str)+"\n";
			  	test_txt.add(str);
			  } 
			  Collections.sort(test_txt);
			  file. ecrireTXT(fileDictionaire.replaceAll(".in", ".txt"),test_txt);
			  
		}
		catch(FileNotFoundException e){
		  e.printStackTrace();
		 }
		catch(IOException e){
		 e.printStackTrace();
		}

	}
	public void loadFileDictionaire()
	{

		  try
		  {		
			  FileInputStream fileIn = new FileInputStream(fileDictionaire);
			  ObjectInputStream in = new ObjectInputStream(fileIn);		
			  listeDeTerme = (Hashtable)in.readObject();			  
			  in.close();
			  fileIn.close();
		  }
		  catch(ClassNotFoundException e){
			  e.printStackTrace();
		  }
		  
		  catch(FileNotFoundException e){
			  e.printStackTrace();
		  }
		  
		  catch(IOException e){
			  e.printStackTrace();
		  }
		  
			  
		  

   /*   	 
      	 System.out.println("Printing out loaded elements key ...");
		 Enumeration e = listeDeTerme.keys(); 
		 //iterate through Hashtable keys Enumeration
		 while(e.hasMoreElements())
		      System.out.println(e.nextElement());
	*/	 
		  
		  
		  /*
		  Collection c = listeDeTerme.values(); 
		  System.out.println("Values of Collection-Values created from Hashtable are :");
		  //iterate through the collection
		  Iterator itr = c.iterator();
		  while(itr.hasNext())
		      System.out.println(itr.next());		     
		  
		  System.out.println();
		   */
		  		  
	}

	
	//***************************************************************************//
	//************** Sauvegarder - Telecharger le fichier  inverse en binaire ***//
	//***************************************************************************//
	private void openFielInverse()
	{
		try {
		    File f = new File(fileInverse);
		    raf = new RandomAccessFile(f, "rw");
		}
		catch (IOException e)
		{
			System.out.println("Ne peut pas ouvrir le fichier Inverse");
		}
	}
	
	private void closeFileInverse()
	{
		try {
			   raf.close();
		}
		catch (IOException e)
		{
			System.out.println("Ne peut pas fermer le fichier Inverse");
		}
	 
	}
	
	private void saveFileInverse(int NumMaxDocument,long Position, int ID) throws IOException
	{
		// File inverse a la structure : Position NumDoc Doc1,Doc2,...,Docn 
		int NumDoc;
		
		try
		{		  		 			
			
		    raf.seek(Position);
		    raf.writeLong(Position);
		    
//			System.out.println("cursus-apres Position: " + 	raf.getFilePointer());	
		    
		    // aller au nombre NumDoc	    	
			try
			{
				NumDoc = raf.readInt()+1;					
			}
			catch(IOException e)
			{			
				NumDoc = 1;		
			}
			
//		  	System.out.println("NumDoc:" + NumDoc);
		  	raf.seek(Position + 8);
			raf.writeInt(NumDoc);
//			System.out.println("cursus -apres NumDoc: " + 	raf.getFilePointer());
			
		    
	     	// Ajouter un Doc a la fin 
			raf.seek(Position + 8 + 4 + (NumDoc-1)*4);
	    	raf.writeInt(ID);
	    	
//	    	System.out.println("cursus -apres ID: " + 	raf.getFilePointer());
//	    	System.out.println("NumID:" + ID);	    
	    	
	    	if ( (Position + 8 + 4 + NumMaxDocument*4) > raf.length())
	    		raf.setLength(Position + 8 + 4 + NumMaxDocument*4);
		
		}
		catch (IOException e)
		{
		}
//		System.out.println("\n\n");
	}
	
	private Vector getListeDoc(long Position)
	{
		Vector resul = new Vector();
		openFielInverse();
		try {
			
		    // aller au nombre NumDoc					
	    	raf.seek(Position + 8);
	    	int NumDoc = raf.readInt();    	
	    
	    	for(int i = 0 ; i < NumDoc; i++)
	    	{
	    		resul.add(raf.readInt());
	    	}	    	
		}
		catch (IOException e)
		{
			resul = null;
		}
		closeFileInverse();
		return resul;
	}
	
	//***************************************************************************//
	//************** Sauvegarder - Telecharger le fichier  inverse en TXT *******//
	//***************************************************************************//
	public void saveFileInverse_TXT()
	{
		File f = new File(fileInverse);
		RandomAccessFile in;
		try {
			in = new RandomAccessFile(f, "r");			
			Vector file_Txt = new Vector();
			try {
				
				while(in.length() != in.getFilePointer())
				{
					String chaine = "";
					long position = in.readLong();
					chaine += position + ":";
					
					int numDoc = in.readInt();
					chaine += numDoc + ":";
					
					for(int i = 0 ; i < numDoc;i++)
					{
						chaine += in.readInt()+",";
					}
					chaine += "\n";
					file_Txt.add(chaine);
					
					in.seek(in.getFilePointer()+(this.getNumMaxDocument()-numDoc)*4);
				}
				
				file.ecrireTXT(fileInverse.replaceAll(".in", ".txt"), file_Txt);
				
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			System.out.println("Ne peut pas ouvrir le fichier Inverse");
		}
		
		
	}
	
	//***************************************************************************//
	//************** Recherche par le modèle booléen ****************************//
	//***************************************************************************//
	
	/* Les argument entrees : String requet sous la forme de :
	 * 			Terme2,Terme6,Terme5,!Terme4,....
	 *  !Terme : est NOT Terme
	 * */
	
	public void rechercheBoolean(String requets)
	{
		// Maintenant, utiliser la version file index ==> version suivante : file inverse
		
		String [] arrayRequest = requets.split(",");		
		
		int [][]matrix = new int[arrayRequest.length][this.NumMaxDocument];
		
		// initial le matrix 
		for(int i = 0 ; i < arrayRequest.length ; i++)
		{
			for(int j = 0 ; j < this.NumMaxDocument; j ++)
				matrix[i][j] = 0;
		}
		
		
		
		// Mettre les valuers 
		for(int i = 0 ; i < arrayRequest.length; i++)
		{
			String terme = arrayRequest[i].toLowerCase();
			terme = terme.trim();
			
			// le cas NOT(terme)
			if(terme.contains(not))
			{
				terme = terme.replace(not, "");
				
				Long position = (Long)this.listeDeTerme.get(terme);
				if(position != null)
				{
					Vector listeDoc = this.getListeDoc(position);
					for(int k = 0 ; k < this.NumMaxDocument; k++)
					{
						if(!listeDoc.contains(k+1))
						{
							matrix[i][k] = 1;
						}
					}
				}
//				else
//				{
//					System.out.println("Terme :" + terme + " n'a pas dans le fichier index");
//					return ;
//				}
				
				
							
			}
			else
			{				
				Long position = (Long)this.listeDeTerme.get(terme);
				if(position != null)
				{
					Vector listeDoc = this.getListeDoc(position);	
				
					for(int k = 0 ; k < this.NumMaxDocument; k++)
					{
						if(listeDoc.contains(k+1))
						{
							matrix[i][k] = 1;
						}
					}
				}
//				else
//				{
//					System.out.println("Terme :" + terme + " n'a pas dans le fichier index");
//					return ;
//				}
				
			
			}
			
		
		}
		
		// Operation AND		
		Vector kq = new Vector();
		for(int j = 0 ; j <  this.NumMaxDocument; j++)	
		{
			int S = 1;
			for(int i = 0 ; i < arrayRequest.length; i ++)
			{
				S = S * matrix[i][j];
			}
			kq.add(S);
		}
	
		if(kq.size()==0)
		{
			System.out.println("Le modèle booléen : ne aucun document satisfaire la rêquête << "+ requets+" >>");
		}
		else
		{
			System.out.println("Le modèle booléen : les documents satisfont la rêquête << "+ requets+" >>");
			
			for(int i = 0 ; i < kq.size() ;i++)
			{		
				
				if((Integer)kq.elementAt(i) > 0)
				{
					int ID = i + 1;
					String nomFile = (String)listeDeDocument.get(ID);
					String[] nomDoc = nomFile.split(File.separator );				
					String resul = "Document :" + nomDoc[nomDoc.length - 1];
					System.out.println(resul);
				
				}
			
			}
		}
		
	
		

	}
	
	
	//***************************************************************************//
	//************** indexation par pondération tf.idf **************************//
	//***************************************************************************//
	
	//Calculer df d'une terme : le nombre de documents qui contiennent le terme t
	private double calculerDF(String terme)
	{
		double df = 0;
		terme = terme.toLowerCase().trim();
		
		
		Long position = (Long)this.listeDeTerme.get(terme);
		if(position != null)
		{
			Vector listeDoc = this.getListeDoc(position);	
			df = listeDoc.size();		
		}	
		return df;
	}
	
	//Calculer idf d'une terme 
	private double calculerIDF(String terme)
	{
		double resul = 0;
		terme = terme.toLowerCase().trim();		
		
		double df = calculerDF(terme);
		resul = Math.log10(this.NumMaxDocument/df);
		
		return resul;
	}
	
	// Calculer tf d'une terme dans un document : fréquence du terme dans le document d
	private double calculerTF(String terme, String Document)
	{
		
		terme = terme.toLowerCase().trim();
				
		float resul = 0;						
		String linge = enleverPonctuation(Document);											
			
		// Supprimer des espaces entre des mots 
		// ex : A     B ==> A B
		linge = linge.replaceAll(expression, separateur);
		linge = linge.trim();
					
		String [] termes = linge.split( separateur );	
			
	//	float NumTerme = termes.length;
		for(int j = 0 ; j < termes.length ; j++)
		{				
			String temp = termes[j].toLowerCase().trim();			
			if(temp.compareTo(terme) == 0)
				resul++;
		}
						
	//	return (resul / NumTerme) ;		
		return resul;
	}
	
	// Calculer tf d'une terme dans un fichier : fréquence du terme dans le fichier
	private double calculerTF_File(String terme, String fichier)
	{
		Vector linges = new Vector();
		linges.addAll(file.lireTxt(fichier));
		double resul = 0;
		
		for(int i = 0 ; i < linges.size();i++)
		{
			String Document = (String)linges.elementAt(i);
			resul += this.calculerTF(terme, Document);
		}
		return resul;
	}
	
	// Calculer tf.idf d'une terme dans un document
	public double calculerTF_IDF(String terme, String documemt)
	{
		double TF = this.calculerTF(terme, documemt);
		double IDF = this.calculerIDF(terme);		
		return TF*IDF;
	}
	
	// Calculer tf.idf d'une terme dans un fichier
	public double calculerTF_IDF_File(String terme, String fichier)
	{
		double TF = this.calculerTF_File(terme, fichier);
		double IDF = this.calculerIDF(terme);		
		return TF*IDF;
	}

	
	//***************************************************************************//
	//************** Recherche par le modèle vectoriel **************************//
	//***************************************************************************//
	
	/* Les argument entrees : String requet sous la forme de :
	 * 			Terme2,Terme6,Terme5,!Terme4,....
	 *  !Terme : est NOT Terme
	 * */
	
	// Calculer la distance avec le document 
	private static double tf_idf ;
	private double calculerDistance(String requet, String fileDocument)
	{
		double RSV = 0;
		Vector Dictionnaire = new Vector();
		
		requet = this.enleverPonctuation(requet);		
		String []listeMots= requet.split(separateur);
		
		
		// Lire des mots dans la requete
		for(int i = 0 ; i < listeMots.length; i++)
			Dictionnaire.add(listeMots[i]);
			
		
		// Lire les mots contient le fichier 
		Vector lignes = new Vector();
		lignes.addAll(file.lireTxt(fileDocument));
		
		for(int i = 0 ; i < lignes.size(); i++)
		{
			String linge = (String)lignes.elementAt(i);
						
			// enlève les ponctuations par ligne	
			linge = enleverPonctuation(linge);						
			
			String [] termes = linge.split( separateur );		
			for(int j = 0 ; j < termes.length ; j++)
			{
				if(!Dictionnaire.contains(termes[j]))
				{
					Dictionnaire.add(termes[j]);
				}
			}
			
		}
		
		//=========== Tri des mots  ============//		
		Collections.sort(Dictionnaire);
				
		//=========== Calculer la matrix  ============//
		// tf_1 : df_1 : idf_1 : w_1 : tf_2 : df_2 : idf_2 : w_2 : produit
		//            REQUETE        :          DOCUMENT         : produit 
		
		int numCol = 9;
		int numLinge = Dictionnaire.size();
		
		double [][]matrix = new double[Dictionnaire.size()][numCol];
		
		// initialize la matrix
		for(int i = 0 ; i < numLinge ; i++)
		{
			for(int j = 0 ; j < numCol; j ++)
			{
				matrix[i][j] = 0;
			}
		}
		
		// Remplir les donnees pour la requete
		
		double sumW1 = 0;
		double sumW2= 0;
		double sumProduit = 0;
		
		for(int i = 0 ; i < numLinge ; i++)
		{
			String terme = (String)Dictionnaire.elementAt(i);
			
			System.out.print("Terme:"+terme +",");
			System.out.println();
			
			// TF 1
			matrix[i][0] = this.calculerTF(terme, requet);
			// DF 1
			matrix[i][1] = this.calculerDF(terme);
			// IDF 1
			matrix[i][2] = this.calculerIDF(terme);
			// W 1
			matrix[i][3] = this.calculerTF_IDF(terme, requet);
			
			sumW1 += matrix[i][3]*matrix[i][3]; 
			
			
			// TF 2 
			matrix[i][4] = this.calculerTF_File(terme, fileDocument);
			// DF 2
			matrix[i][5] = matrix[i][1];
			// IDF 2
			matrix[i][6] = matrix[i][2];
			// W 2
			matrix[i][7] = this.calculerTF_IDF_File(terme, fileDocument);
			
			sumW2 += matrix[i][7] * matrix[i][7];
			
			
			// produit : w1 * w2
			matrix[i][8] = matrix[i][3] * matrix[i][7];
			
			sumProduit += matrix[i][8];
			
		}
		
		System.out.println(fileDocument);
		for(int i = 0 ; i < numLinge ; i++)
		{
			for(int j = 0 ; j < numCol; j ++)
			{
				System.out.print(matrix[i][j]+", ");
			}
			System.out.println();
		}
	
		
		
		
		
		tf_idf = Math.sqrt(sumW1);
		
		System.out.println("Sum d :" + Math.sqrt(sumW2));
		System.out.println("Sum produit :" + sumProduit);
		System.out.println("\n\n");
		
		RSV = sumProduit / (Math.sqrt(sumW1) * Math.sqrt(sumW2));		
		
		return RSV;	
	}
	
	public void rechercheVectoriel(String requets)
	{
		Vector distance = new Vector();		
		Collection c = listeDeDocument.values(); 
		
		Hashtable listeDistance = new Hashtable();
		
		
		Iterator itr = c.iterator();
		while(itr.hasNext())
		{

			try
			{
				String fileDocument = (String)itr.next();
				
				// Caculer la distance 
				double dis = this.calculerDistance(requets, fileDocument);
				
				if(dis >= 0)
				{
//					System.out.println("distance:"+ dis);
					distance.add(dis);						
					// Sauvergarder dans la hash table 
					listeDistance.put(dis, fileDocument);
				}
				
			}
			catch (Exception e)
			{
				// TODO Auto-generated catch block

			}
		
		}	
		
		// Sort les distance descending
		Collections.sort(distance);
		Collections.reverse(distance);
		
		if(distance.size()==0)
		{
			System.out.println("Le modèle vectoriel : ne aucun document satisfaire la rêquête << "+ requets+" >>");
		}
		else
		{
			System.out.println("Le modèle vectoriel : les documents satisfont la rêquête << "+ requets+" >>");
			System.out.println("le poids tf.idf pour la requête << "+ requets+" >> : " + tf_idf);
			// Lire nom document dans la hash table
			// Donner 10 resultat maximaux 
			for(int i = 0 ; i < distance.size() && i < 10 ;i++)
			{
				String nomFile = (String)listeDistance.get(distance.elementAt(i));
				String[] nomDoc = nomFile.split(File.separator );				
				String resul = "Document :" + nomDoc[nomDoc.length - 1] + " ;S:" + distance.elementAt(i);
				System.out.println(resul);

			}
		}
		
	
	}
	
}
